package com.zby.admin.service.imp;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zby.admin.mapper.*;
import com.zby.admin.pojo.*;
import com.zby.admin.pojo.dto.ProductOrderDTO;
import com.zby.admin.pojo.vo.ProductOrderVo;
import com.zby.admin.service.ProductOrderService;
import com.zby.enums.OrderStatus;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import jakarta.annotation.Resource;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ProductOrderServiceImp extends ServiceImpl<ProductOrderMapper, ProductOrder> implements ProductOrderService {

    @Resource
    private ProductOrderMapper productOrderMapper;

    @Resource
    private ProductOrderItemMapper productOrderItemMapper;
    @Resource
    private AddressMapper addressMapper;
    @Resource
    private ProductsMapper productsMapper;

    @Transactional(rollbackFor = Exception.class)
    public boolean addData(ProductOrderDTO productOrderDTO, HttpServletRequest request) {
        // 获取用户ID
        Object userId = request.getSession().getAttribute("userId");
        // 禁止自己购买自己
        Products products = productsMapper.selectById(productOrderDTO.getProductId());
        if(products==null || userId == null){
            return false;
        }
        if (userId.toString().equals(products.getUserId())) {
            return false;
        }

        Long userIdLong = Long.parseLong(userId.toString());
        if (productOrderDTO == null || productOrderDTO.getProductId() == null) {
            return false;
        }

        // 创建订单
        ProductOrder productOrder = new ProductOrder();
        productOrder.setUserId(userIdLong);
        Address address = addressMapper.selectById(productOrderDTO.getAddressId());
        if(address== null ){
            return false;
        }
        //判断地址用户和订单用户一致
        if (!address.getUserId().equals(userIdLong)) {
            return false;
        }
        // 简单生成订单号
        productOrder.setProductOrderCode(productionOrderNumber());
        productOrder.setProductOrderPost(address.getPostalCode());
        productOrder.setProductOrderReceiver(address.getReceiverName());
        productOrder.setProductOrderMobile(address.getReceiverPhone());
        productOrder.setProductOrderDetailAddress(address.getDetailAddress());
        productOrder.setProductOrderPayDate(LocalDateTime.now());
        // 设置卖家 ID
        productOrder.setSellerId(productOrderDTO.getSellerId());
        // 默认待付款状态
        productOrder.setProductOrderStatus(productOrderDTO.getProductOrderStatus());
        productOrder.setProductOrderTotalPrice(productOrderDTO.getProductOrderTotalPrice());

        // 保存订单
        int orderResult = productOrderMapper.insert(productOrder);

        // 创建订单项
        ProductOrderItem productOrderItem = new ProductOrderItem();
        // 默认数量
        productOrderItem.setProductOrderItemNumber(productOrderDTO.getProductOrderItemNumber());

        productOrderItem.setProductOrderItemPrice(productOrderDTO.getProductOrderItemPrice());
        productOrderItem.setProductOrderItemUser(userIdLong);
        // 关联订单
        productOrderItem.setProductOrderItemId(productOrder.getProductOrderCode());
        // 关联商品
        productOrderItem.setProductOrderItemProduct(productOrderDTO.getProductId());
        // 默认无用户备注
        productOrderItem.setProductOrderItemUserMessage(productOrderDTO.getProductOrderUserMessage());

        // 保存订单项
        int itemResult = productOrderItemMapper.insert(productOrderItem);

        return orderResult > 0 && itemResult > 0;
    }
    
    @Override
    public List<ProductOrderVo> getPersonalOrder(HttpServletRequest request) {
        // 获取用户ID
        Object userId = request.getSession().getAttribute("userId");
        if (userId == null) {
            return null;
        }
        Long userIdLong = Long.parseLong(userId.toString());

        // 查询该用户的所有订单
        LambdaQueryWrapper<ProductOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductOrder::getUserId, userIdLong);
        List<ProductOrder> productOrders = this.list(queryWrapper);

        // 转换为VO对象
        List<ProductOrderVo> productOrderVos = productOrders.stream().map(productOrder -> {
            ProductOrderVo productOrderVo = new ProductOrderVo();
            BeanUtils.copyProperties(productOrder, productOrderVo);
            
            // 查询订单项
            LambdaQueryWrapper<ProductOrderItem> itemQueryWrapper = new LambdaQueryWrapper<>();
            itemQueryWrapper.eq(ProductOrderItem::getProductOrderItemId, productOrder.getProductOrderCode());
            List<ProductOrderItem> productOrderItems = productOrderItemMapper.selectList(itemQueryWrapper);
            
            // 处理商品标题：如果有多个商品，显示所有商品标题，用逗号分隔
            if (productOrderItems != null && !productOrderItems.isEmpty()) {
                StringBuilder productTitles = new StringBuilder();
                for (int i = 0; i < productOrderItems.size(); i++) {
                    ProductOrderItem item = productOrderItems.get(i);
                    Products product = productsMapper.selectById(item.getProductOrderItemProduct());
                    if (product != null) {
                        if (i > 0) {
                            productTitles.append(", ");
                        }
                        productTitles.append(product.getTitle());
                    }
                }
                productOrderVo.setProductTitle(productTitles.toString());
            }
            
            productOrderVo.setProductOrderItems(productOrderItems);
            return productOrderVo;
        }).collect(Collectors.toList());

        return productOrderVos;
    }

    @Override
    public List<ProductOrderVo> getPersonalSellOrder(Integer sallerId, HttpServletRequest request) {
        // 获取用户ID
        Object userId = request.getSession().getAttribute("userId");
        if (userId == null) {
            // 用户未登录，返回null让Controller层处理
            return null;
        }
        
        // 查询该卖家的所有订单
        QueryWrapper<ProductOrder> productOrderQueryWrapper = new QueryWrapper<>();
        productOrderQueryWrapper.eq("seller_id", sallerId);
        List<ProductOrder> productOrders = productOrderMapper.selectList(productOrderQueryWrapper);
        
        // 转换为VO对象并查询订单项
        if(productOrders != null && !productOrders.isEmpty()){
            return productOrders.stream().map(productOrder -> {
                ProductOrderVo productOrderVo = new ProductOrderVo();
                BeanUtils.copyProperties(productOrder, productOrderVo);

                // 查询订单项
                LambdaQueryWrapper<ProductOrderItem> itemQueryWrapper = new LambdaQueryWrapper<>();
                itemQueryWrapper.eq(ProductOrderItem::getProductOrderItemId, productOrder.getProductOrderCode());
                List<ProductOrderItem> productOrderItems = productOrderItemMapper.selectList(itemQueryWrapper);
                
                // 处理商品标题：如果有多个商品，显示所有商品标题，用逗号分隔
                if (productOrderItems != null && !productOrderItems.isEmpty()) {
                    StringBuilder productTitles = new StringBuilder();
                    for (int i = 0; i < productOrderItems.size(); i++) {
                        ProductOrderItem item = productOrderItems.get(i);
                        Products product = productsMapper.selectById(item.getProductOrderItemProduct());
                        if (product != null) {
                            if (i > 0) {
                                productTitles.append(", ");
                            }
                            productTitles.append(product.getTitle());
                        }
                    }
                    productOrderVo.setProductTitle(productTitles.toString());
                }
                
                productOrderVo.setProductOrderItems(productOrderItems);
                return productOrderVo;
            }).collect(Collectors.toList());
        }
        
        // 没有查询到订单时返回空列表而不是null
        return new ArrayList<>();
    }


    @Override
    public boolean updateOrderStatus(ProductOrderDTO productOrderDTO, HttpServletRequest request) {
        // 判断是否登录
        Object userId = request.getSession().getAttribute("userId");
        if (userId == null) {
            System.out.println("用户未登录或会话已过期");
            return false;
        }
        Long userIdLong = Long.parseLong(userId.toString());
        
        // 检查订单是否存在
        LambdaQueryWrapper<ProductOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductOrder::getProductOrderCode, productOrderDTO.getProductOrderCode());
        ProductOrder productOrder = productOrderMapper.selectOne(queryWrapper);
        if (productOrder == null) {
            System.out.println("订单不存在");
            return false;
        }
        
        // 判断用户是否有权限修改该订单状态
        // 买家可以操作：取消订单(交易关闭)、确认收货(已确认)
        // 卖家可以操作：发货(已发货)、待确认
        boolean isBuyer = productOrder.getUserId().equals(userIdLong);
        boolean isSeller = productOrder.getSellerId().equals(userIdLong);
        
        if (!isBuyer && !isSeller) {
            System.out.println("用户没有权限操作该订单");
            return false;
        }
        
        // 根据用户角色和目标状态进行验证
        OrderStatus targetStatus = productOrderDTO.getProductOrderStatus();
        OrderStatus currentStatus = productOrder.getProductOrderStatus();
        
        // 验证状态流转是否合法
        if (!isValidStatusTransition(currentStatus, targetStatus, isBuyer, isSeller)) {
            System.out.println("订单状态流转不合法");
            return false;
        }
        
        // 更新订单状态
        productOrder.setProductOrderStatus(targetStatus);
        
        // 根据状态设置相关时间字段
        LocalDateTime now = LocalDateTime.now();
        switch (targetStatus) {
            case DELIVERED: // 已发货
                productOrder.setProductOrderDeliveryDate(now);
                break;
            case CONFIRMED: // 已确认（买家确认收货）
                productOrder.setProductOrderConfirmDate(now);
                break;
            case CLOSED: // 交易关闭
                // 可以设置关闭时间（如果需要）
                break;
            default:
                break;
        }
        
        // 更新数据库
        int result = productOrderMapper.updateById(productOrder);
        return result > 0;
    }

    @Override
    public Page<ProductOrderVo> getAllOrderList(Integer page, Integer pageSize, String productTitle) {
        // 分页查询订单
        Page<ProductOrder> orderPage = new Page<>(page, pageSize);
        LambdaQueryWrapper<ProductOrder> queryWrapper = new LambdaQueryWrapper<>();
        
        // 如果提供了商品标题搜索条件，则需要关联查询订单项和商品表
        if (productTitle != null && !productTitle.trim().isEmpty()) {
            // 先查询符合条件的商品
            LambdaQueryWrapper<Products> productQueryWrapper = new LambdaQueryWrapper<>();
            productQueryWrapper.like(Products::getTitle, productTitle);
            List<Products> productsList = productsMapper.selectList(productQueryWrapper);
            
            // 提取商品ID
            List<Long> productIds = productsList.stream()
                    .map(product -> Long.valueOf(product.getId()))
                    .collect(Collectors.toList());
            
            // 如果没有匹配的商品，则返回空列表
            if (productIds.isEmpty()) {
                Page<ProductOrderVo> emptyPage = new Page<>(page, pageSize, 0);
                emptyPage.setRecords(new ArrayList<>());
                return emptyPage;
            }
            
            // 查询包含这些商品的订单项
            LambdaQueryWrapper<ProductOrderItem> itemQueryWrapper = new LambdaQueryWrapper<>();
            itemQueryWrapper.in(ProductOrderItem::getProductOrderItemProduct, productIds);
            List<ProductOrderItem> orderItems = productOrderItemMapper.selectList(itemQueryWrapper);
            
            // 提取订单号
            List<Long> orderCodes = orderItems.stream()
                    .map(ProductOrderItem::getProductOrderItemId)
                    .distinct()
                    .collect(Collectors.toList());
            
            // 如果没有匹配的订单项，则返回空列表
            if (orderCodes.isEmpty()) {
                Page<ProductOrderVo> emptyPage = new Page<>(page, pageSize, 0);
                emptyPage.setRecords(new ArrayList<>());
                return emptyPage;
            }
            
            // 在订单查询中添加订单号条件
            queryWrapper.in(ProductOrder::getProductOrderCode, orderCodes);
        }
        
        // 执行分页查询
        Page<ProductOrder> productOrderPage = productOrderMapper.selectPage(orderPage, queryWrapper);
        List<ProductOrder> productOrders = productOrderPage.getRecords();
        
        // 转换为VO对象并查询订单项
        List<ProductOrderVo> productOrderVos = productOrders.stream().map(productOrder -> {
            ProductOrderVo productOrderVo = new ProductOrderVo();
            BeanUtils.copyProperties(productOrder, productOrderVo);

            // 查询订单项
            LambdaQueryWrapper<ProductOrderItem> itemQueryWrapper = new LambdaQueryWrapper<>();
            itemQueryWrapper.eq(ProductOrderItem::getProductOrderItemId, productOrder.getProductOrderCode());
            List<ProductOrderItem> productOrderItems = productOrderItemMapper.selectList(itemQueryWrapper);
            
            // 处理商品标题：如果有多个商品，显示所有商品标题，用逗号分隔
            if (productOrderItems != null && !productOrderItems.isEmpty()) {
                StringBuilder productTitles = new StringBuilder();
                for (int i = 0; i < productOrderItems.size(); i++) {
                    ProductOrderItem item = productOrderItems.get(i);
                    Products product = productsMapper.selectById(item.getProductOrderItemProduct());
                    if (product != null) {
                        if (i > 0) {
                            productTitles.append(", ");
                        }
                        productTitles.append(product.getTitle());
                    }
                }
                productOrderVo.setProductTitle(productTitles.toString());
            }
            
            productOrderVo.setProductOrderItems(productOrderItems);
            return productOrderVo;
        }).collect(Collectors.toList());
        
        // 构建返回的分页对象
        Page<ProductOrderVo> productOrderVoPage = new Page<>(productOrderPage.getCurrent(), productOrderPage.getSize(), productOrderPage.getTotal());
        productOrderVoPage.setRecords(productOrderVos);
        
        return productOrderVoPage;
    }

    /**
     * 验证订单状态流转是否合法
     * @param currentStatus 当前状态
     * @param targetStatus 目标状态
     * @param isBuyer 是否为买家操作
     * @param isSeller 是否为卖家操作
     * @return 是否合法
     */
    private boolean isValidStatusTransition(OrderStatus currentStatus, OrderStatus targetStatus, 
                                          boolean isBuyer, boolean isSeller) {
        // 验证订单状态参数
        if (currentStatus == null || targetStatus == null) {
            System.out.println("订单状态参数错误");
            return false;
        }
        
        // 买家操作规则
        if (isBuyer) {
            switch (currentStatus) {
                // 待付款状态
                case WAIT_PAYMENT:
                    // 仅允许取消订单
                    return targetStatus == OrderStatus.CLOSED;
                // 待确认状态
                case DELIVERED:
                    // 仅允许确认收货
                    return targetStatus == OrderStatus.CONFIRMED || targetStatus == OrderStatus.RETURNED;
                // 待确认状态
                case WAIT_DELIVER:
                    // 仅允许取消订单
                    return targetStatus == OrderStatus.RETURNED;
                // 已确认状态
                case CONFIRMED:
                    // 仅允许申请退货
                    return targetStatus == OrderStatus.RETURNED;
                default:
                    // 其他状态不允许买家操作
                    System.out.println("买家操作错误");
                    return false;
            }
        }
        
        // 卖家操作规则
        if (isSeller) {
            switch (currentStatus) {
                // 待发货状态
                case WAIT_DELIVER:
                    // 仅允许发货
                    return targetStatus == OrderStatus.DELIVERED;
                // 已发货状态
                case DELIVERED:
                    // 仅允许标记为待确认
                    return targetStatus == OrderStatus.WAIT_CONFIRM;
                case RETURNED:
                    return targetStatus == OrderStatus.RETURN_SUCCESS || targetStatus == OrderStatus.RETURN_FAIL;
                    
                default:
                    // 其他状态不允许卖家操作
                    System.out.println("卖家操作错误");
                    return false;
            }
        }
        
        return false;
    }

    private Long productionOrderNumber() {
        // 时间+用户id+随机数
        Long number = System.currentTimeMillis()+ (int) (Math.random() * 100000);
        return number;
    }
    
    @Override
    public Page<ProductOrderVo> getReturningOrder(Integer page, Integer pageSize) {
        // 创建分页对象
        Page<ProductOrder> orderPage = new Page<>(page, pageSize);
        
        // 查询退货中的订单
        LambdaQueryWrapper<ProductOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProductOrder::getProductOrderStatus, com.zby.enums.OrderStatus.RETURNED);
        
        // 执行分页查询
        Page<ProductOrder> productOrderPage = productOrderMapper.selectPage(orderPage, queryWrapper);
        List<ProductOrder> productOrders = productOrderPage.getRecords();
        
        // 转换为VO对象并查询订单项
        List<ProductOrderVo> productOrderVos = productOrders.stream().map(productOrder -> {
            ProductOrderVo productOrderVo = new ProductOrderVo();
            BeanUtils.copyProperties(productOrder, productOrderVo);

            // 查询订单项
            LambdaQueryWrapper<ProductOrderItem> itemQueryWrapper = new LambdaQueryWrapper<>();
            itemQueryWrapper.eq(ProductOrderItem::getProductOrderItemId, productOrder.getProductOrderCode());
            List<ProductOrderItem> productOrderItems = productOrderItemMapper.selectList(itemQueryWrapper);
            
            // 处理商品标题：如果有多个商品，显示所有商品标题，用逗号分隔
            if (productOrderItems != null && !productOrderItems.isEmpty()) {
                StringBuilder productTitles = new StringBuilder();
                for (int i = 0; i < productOrderItems.size(); i++) {
                    ProductOrderItem item = productOrderItems.get(i);
                    Products product = productsMapper.selectById(item.getProductOrderItemProduct());
                    if (product != null) {
                        if (i > 0) {
                            productTitles.append(", ");
                        }
                        productTitles.append(product.getTitle());
                    }
                }
                productOrderVo.setProductTitle(productTitles.toString());
            }
            
            productOrderVo.setProductOrderItems(productOrderItems);
            return productOrderVo;
        }).collect(Collectors.toList());
        
        // 构建返回的分页对象
        Page<ProductOrderVo> productOrderVoPage = new Page<>(productOrderPage.getCurrent(), productOrderPage.getSize(), productOrderPage.getTotal());
        productOrderVoPage.setRecords(productOrderVos);
        
        return productOrderVoPage;
    }
}